/* packet.c
 * Routines for packet disassembly
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include <glib.h>

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

#include <stdarg.h>
#include <string.h>
#include <time.h>

#include "tvbuff.h"
#include "packet.h"

#include "strutil.h"
#include "wmem_strutils.h"

static int proto_malformed;
static dissector_handle_t frame_handle;
static dissector_handle_t file_handle;
static dissector_handle_t data_handle;

/**
 * A data source.
 * Has a tvbuff and a name.
 */
struct data_source {
    tvbuff_t *tvb;
    char *name;
};

/*
 * A dissector table.
 *
 * "hash_table" is a hash table, indexed by port number, supplying
 * a "struct dtbl_entry"; it records what dissector is assigned to
 * that uint or string value in that table.
 *
 * "dissector_handles" is a list of all dissectors that *could* be
 * used in that table; not all of them are necessarily in the table,
 * as they may be for protocols that don't have a fixed uint value,
 * e.g. for TCP or UDP port number tables and protocols with no fixed
 * port number.
 *
 * "ui_name" is the name the dissector table has in the user interface.
 *
 * "type" is a field type giving the width of the uint value for that
 * dissector table, if it's a uint dissector table.
 *
 * "param" is the base in which to display the uint value for that
 * dissector table, if it's a uint dissector table, or if it's a string
 * table, true/false to indicate case-insensitive or not.
 *
 * "protocol" is the protocol associated with the dissector table. Used
 * for determining dependencies.
 */
struct dissector_table {
    GHashTable *hash_table;
    GSList     *dissector_handles;
    const char *ui_name;
    ftenum_t    type;
    int         param;
    protocol_t *protocol;
    GHashFunc   hash_func;
};

/*
 * Dissector tables. const char * -> dissector_table *
 */
static GHashTable *dissector_tables;

/*
 * Dissector table aliases. const char * -> const char *
 */
static GHashTable *dissector_table_aliases;

/*
 * List of registered dissectors.
 */
static GHashTable *registered_dissectors;

/*
 * A dissector dependency list.
 */
struct depend_dissector_list {
    GSList        *dissectors;
};

/* Maps char *dissector_name to depend_dissector_list_t */
static GHashTable *depend_dissector_lists;

/* Allow protocols to register a "cleanup" routine to be
 * run after the initial sequential run through the packets.
 * Note that the file can still be open after this; this is not
 * the final cleanup. */
static GSList *postseq_cleanup_routines;

/*
 * Post-dissector information - handle for the dissector and a list
 * of hfids for the fields the post-dissector wants.
 */
typedef struct {
    dissector_handle_t handle;
    GArray *wanted_hfids;
} postdissector;

/*
 * Array of all postdissectors.
 */
static GArray *postdissectors;

/*
 * i-th element of that array.
 */
#define POSTDISSECTORS(i)    g_array_index(postdissectors, postdissector, i)

static void destroy_depend_dissector_list(void *data)
{
    depend_dissector_list_t dissector_list = (depend_dissector_list_t)data;
    GSList **list = &(dissector_list->dissectors);

    g_slist_free_full(*list, g_free);
    g_slice_free(struct depend_dissector_list, dissector_list);
}


static void destroy_dissector_table(void *data)
{
    struct dissector_table *table = (struct dissector_table *)data;

    g_hash_table_destroy(table->hash_table);
    g_slist_free(table->dissector_handles);
    g_slice_free(struct dissector_table, data);
}

void packet_init(void)
{
    dissector_tables = g_hash_table_new_full(g_str_hash, g_str_equal,
            NULL, destroy_dissector_table);

    dissector_table_aliases = g_hash_table_new_full(g_str_hash, g_str_equal,
            NULL, NULL);

    registered_dissectors = g_hash_table_new_full(g_str_hash, g_str_equal,
            NULL, NULL);

    depend_dissector_lists = g_hash_table_new_full(g_str_hash, g_str_equal,
            g_free, destroy_depend_dissector_list);
}

//void packet_cache_proto_handles(void)
//{
//    frame_handle = find_dissector("frame");
//    ws_assert(frame_handle != NULL);

//    file_handle = find_dissector("file");
//    ws_assert(file_handle != NULL);

//    data_handle = find_dissector("data");
//    ws_assert(data_handle != NULL);

//    proto_malformed = proto_get_id_by_filter_name("_ws.malformed");
//    ws_assert(proto_malformed != -1);
//}

/* List of routines that are called before we make a pass through a capture file
 * and dissect all its packets. See register_init_routine, register_cleanup_routine
 * and register_shutdown_routine in packet.h */
/**
 * List of "init" routines, which are called before we make a pass through
 * a capture file and dissect all its packets (e.g., when we read in a
 * new capture file, or run a "filter packets" or "colorize packets"
 * pass over the current capture file or when the preferences are changed).
 *
 * See register_init_routine().
 */
//static GSList *init_routines;

/**
 * List of "cleanup" routines, which are called after closing a capture
 * file (or when preferences are changed; in that case these routines
 * are called before the init routines are executed). They can be used
 * to release resources that are allocated in an "init" routine.
 *
 * See register_cleanup_routine().
 */
//static GSList *cleanup_routines;

/*
 * List of "shutdown" routines, which are called once, just before
 * program exit.
 *
 * See register_shutdown_routine().
 */
static GSList *shutdown_routines;

typedef void (*void_func_t)(void);

/* Initialize all data structures used for dissection. */
static void call_routine(void *routine, void *dummy)
{
    void_func_t func = (void_func_t)routine;
    (*func)();
}

void packet_cleanup(void)
{
//    g_slist_free(init_routines);
//    g_slist_free(cleanup_routines);
    g_slist_free(postseq_cleanup_routines);
    g_hash_table_destroy(dissector_tables);
    g_hash_table_destroy(dissector_table_aliases);
    g_hash_table_destroy(registered_dissectors);
    g_hash_table_destroy(depend_dissector_lists);
//    g_hash_table_destroy(heur_dissector_lists);
//    g_hash_table_destroy(heuristic_short_names);
    g_slist_foreach(shutdown_routines, &call_routine, NULL);
    g_slist_free(shutdown_routines);
    if (postdissectors) {
        for (unsigned i = 0; i < postdissectors->len; i++) {
            if (POSTDISSECTORS(i).wanted_hfids) {
                g_array_free(POSTDISSECTORS(i).wanted_hfids, true);
            }
        }
        g_array_free(postdissectors, true);
    }
}

/*
 * Given a tvbuff, and a length from a packet header, adjust the length
 * of the tvbuff to reflect the specified length.
 */
void set_actual_length(tvbuff_t *tvb, const unsigned specified_len)
{
//    if (specified_len < tvb_reported_length(tvb)) {
        /* Adjust the length of this tvbuff to include only the specified
           payload length.

           The dissector above the one calling us (the dissector above is
           probably us) may use that to determine how much of its packet
           was padding. */
//        tvb_set_reported_length(tvb, specified_len);
//    }
}

//void
//register_init_routine(void (*func)(void))
//{
//    init_routines = g_slist_prepend(init_routines, (void *)func);
//}

//void
//register_cleanup_routine(void (*func)(void))
//{
//    cleanup_routines = g_slist_prepend(cleanup_routines, (void *)func);
//}

/* register a new shutdown routine */
void register_shutdown_routine(void (*func)(void))
{
    shutdown_routines = g_slist_prepend(shutdown_routines, (void *)func);
}

/* Initialize all data structures used for dissection. */
void init_dissection(void)
{
    /*
     * Reinitialize resolution information. Don't leak host entries from
     * one file to another (e.g. embarrassing-host-name.example.com from
     * file1.pcapng into a name resolution block in file2.pcapng).
     */
//    host_name_lookup_reset();

//    wmem_enter_file_scope();

    /* Initialize the table of conversations. */
//    epan_conversation_init();

    /* Initialize protocol-specific variables. */
//    g_slist_foreach(init_routines, &call_routine, NULL);

    /* Initialize the stream-handling tables */
//    stream_init();

    /* Initialize the expert infos */
//    expert_packet_init();
}

void cleanup_dissection(void)
{
    /* Cleanup protocol-specific variables. */
//    g_slist_foreach(cleanup_routines, &call_routine, NULL);

    /* Cleanup the stream-handling tables */
//    stream_cleanup();

    /* Cleanup the expert infos */
//    expert_packet_cleanup();

//    wmem_leave_file_scope();

    /*
     * Keep the name resolution info around until we start the next
     * dissection. Lua scripts may potentially do name resolution at
     * any time, even if we're not dissecting and have no capture
     * file open.
     */
}

void register_postseq_cleanup_routine(void_func_t func)
{
    postseq_cleanup_routines = g_slist_prepend(postseq_cleanup_routines,
            (void *)func);
}

/* Call all the registered "postseq_cleanup" routines. */
void postseq_cleanup_all_protocols(void)
{
    g_slist_foreach(postseq_cleanup_routines,
            &call_routine, NULL);
}

/*
 * Add a new data source to the list of data sources for a frame, given
 * the tvbuff for the data source and its name.
 */
void add_new_data_source(packet_info *pinfo, tvbuff_t *tvb, const char *name)
{
    struct data_source *src;

    src = malloc(sizeof(struct data_source));
    src->tvb = tvb;
    src->name = strdup(name);
    /* This could end up slow, but we should never have that many data
     * sources so it probably doesn't matter */
    pinfo->data_src = g_slist_append(pinfo->data_src, src);
}

void remove_last_data_source(packet_info *pinfo)
{
    GSList *last;

    last = g_slist_last(pinfo->data_src);
    pinfo->data_src = g_slist_delete_link(pinfo->data_src, last);
}

char *get_data_source_name(const struct data_source *src)
{
    unsigned length = tvb_captured_length(src->tvb);

    return wmem_strdup_printf("%s (%u byte%s)", src->name, length,
                plurality(length, "", "s"));
}

tvbuff_t *get_data_source_tvb(const struct data_source *src)
{
    return src->tvb;
}

/*
 * Find and return the tvb associated with the given data source name
 */
tvbuff_t *get_data_source_tvb_by_name(packet_info *pinfo, const char *name)
{
    GSList *source;
    for (source = pinfo->data_src; source; source = source->next) {
        struct data_source *this_source = (struct data_source *)source->data;
        if (this_source->name && strcmp(this_source->name, name) == 0) {
            return this_source->tvb;
        }
    }
    return NULL;
}


/*
 * Free up a frame's list of data sources.
 */
void free_data_sources(packet_info *pinfo)
{
    if (pinfo && pinfo->data_src) {
        GSList *source;
        for (source = pinfo->data_src; source; source = source->next) {
            struct data_source *src = (struct data_source *)source->data;
            free(src->name);
        }
        g_slist_free(pinfo->data_src);
        pinfo->data_src = NULL;
    }
}


/*********************** code added for sub-dissector lookup *********************/

enum dissector_e {
    DISSECTOR_TYPE_SIMPLE,
    DISSECTOR_TYPE_CALLBACK
};

/*
 * A dissector handle.
 */
struct dissector_handle {
    const char    *name;        /* dissector name */
    const char    *description;    /* dissector description */
    char            *pref_suffix;
    enum dissector_e dissector_type;
    union {
        dissector_t    dissector_type_simple;
//        dissector_cb_t    dissector_type_callback;
    } dissector_func;
    void        *dissector_data;
    protocol_t    *protocol;
};

static void add_layer(packet_info *pinfo, int proto_id)
{
    int *proto_layer_num_ptr;

    pinfo->curr_layer_num++;
//    wmem_list_append(pinfo->layers, GINT_TO_POINTER(proto_id));

    /* Increment layer number for this proto id. */
//    if (pinfo->proto_layers == NULL) {
//        pinfo->proto_layers = wmem_map_new(pinfo->pool, g_direct_hash, g_direct_equal);
//    }

//    proto_layer_num_ptr = wmem_map_lookup(pinfo->proto_layers, GINT_TO_POINTER(proto_id));
//    if (proto_layer_num_ptr == NULL) {
//        /* Insert new layer */
//        proto_layer_num_ptr = wmem_new(int);
//        *proto_layer_num_ptr = 1;
//        wmem_map_insert(pinfo->proto_layers, GINT_TO_POINTER(proto_id), proto_layer_num_ptr);
//    }
//    else {
//        /* Increment layer number */
//        (*proto_layer_num_ptr)++;
//    }
    pinfo->curr_proto_layer_num++;// = *proto_layer_num_ptr;
}

static void remove_last_layer(packet_info *pinfo, bool reduce_count)
{
//    int *proto_layer_num_ptr;
//    wmem_list_frame_t *frame;
//    int proto_id;

    if (reduce_count) {
        pinfo->curr_layer_num--;
        pinfo->curr_proto_layer_num--;
    }

//    frame = wmem_list_tail(pinfo->layers);
//    proto_id = GPOINTER_TO_INT(wmem_list_frame_data(frame));
//    wmem_list_remove_frame(pinfo->layers, frame);

//    if (reduce_count) {
//        /* Reduce count for removed protocol layer. */
//        proto_layer_num_ptr = wmem_map_lookup(pinfo->proto_layers, GINT_TO_POINTER(proto_id));
//        if (proto_layer_num_ptr && *proto_layer_num_ptr > 0) {
//            (*proto_layer_num_ptr)--;
//        }
//    }

//    /* Restore count for new last (protocol) layer. */
//    frame = wmem_list_tail(pinfo->layers);
//    if (frame) {
//        proto_id = GPOINTER_TO_INT(wmem_list_frame_data(frame));
//        proto_layer_num_ptr = wmem_map_lookup(pinfo->proto_layers, GINT_TO_POINTER(proto_id));
//        ws_assert(proto_layer_num_ptr);
//        pinfo->curr_proto_layer_num = *proto_layer_num_ptr;
//    }
}


/* This function will return
 *   >0  this protocol was successfully dissected and this was this protocol.
 *   0   this packet did not match this protocol.
 *
 * XXX - if the dissector only dissects metadata passed through the data
 * pointer, and dissects none of the packet data, that's indistinguishable
 * from "packet did not match this protocol".  See issues #12366 and
 * #12368.
 */
static int call_dissector_through_handle(dissector_handle_t handle,
                                         tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
{printf("call_dissector_through_handle: %s, %p, %d, %p\n",  handle->name, handle->protocol,
                                                    handle->dissector_type, handle->dissector_func.dissector_type_simple);fflush(stdout);
    const char *saved_proto;
    int         len;

    saved_proto = pinfo->proto_name;

    if ((handle->protocol != NULL) && (!proto_is_pino(handle->protocol))) {
        pinfo->proto_name =
            proto_get_protocol_short_name(handle->protocol);
    }
    switch (handle->dissector_type) {

    case DISSECTOR_TYPE_SIMPLE: {
        len = (handle->dissector_func.dissector_type_simple)(tvb, pinfo, tree, data);
    }
        break;

//    case DISSECTOR_TYPE_CALLBACK:
//        len = (handle->dissector_func.dissector_type_callback)(tvb, pinfo, tree, data, handle->dissector_data);
//        break;

    default:
        break;
    }
    pinfo->proto_name = saved_proto;

    return len;
}

/*
 * Call a dissector through a handle.
 * If the protocol for that handle isn't enabled, return 0 without
 * calling the dissector.
 * Otherwise, if the handle refers to a new-style dissector, call the
 * dissector and return its return value, otherwise call it and return
 * the length of the tvbuff pointed to by the argument.
 */

//static int
//call_dissector_work_error(dissector_handle_t handle, tvbuff_t *tvb,
//              packet_info *pinfo_arg, proto_tree *tree, void *);

static int call_dissector_work(dissector_handle_t handle,
                               tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                               bool add_proto_name, void *data)
{
    const char  *saved_proto;
//    uint16_t     saved_can_desegment;
    int          len;
//    unsigned     saved_layers_len = 0;
//    unsigned     saved_tree_count = tree ? tree->tree_data->count : 0;
//    unsigned     saved_desegment_len = pinfo->desegment_len;
//    bool         consumed_none;

    if (handle->protocol != NULL &&
        !proto_is_protocol_enabled(handle->protocol)) {
        /*
         * The protocol isn't enabled.
         */
        return 0;
    }

    saved_proto = pinfo->proto_name;
//    saved_can_desegment = pinfo->can_desegment;
//    saved_layers_len = wmem_list_count(pinfo->layers);
//    DISSECTOR_ASSERT(saved_layers_len < prefs.gui_max_tree_depth);

    /*
     * can_desegment is set to 2 by anyone which offers the
     * desegmentation api/service.
     * Then every time a subdissector is called it is decremented
     * by one.
     * Thus only the subdissector immediately on top of whoever
     * offers this service can use it.
     * We save the current value of "can_desegment" for the
     * benefit of TCP proxying dissectors such as SOCKS, so they
     * can restore it and allow the dissectors they call to use
     * the desegmentation service.
     */
//    pinfo->saved_can_desegment = saved_can_desegment;
//    pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
    if ((handle->protocol != NULL) && (!proto_is_pino(handle->protocol))) {
        pinfo->proto_name =
            proto_get_protocol_short_name(handle->protocol);

        /*
         * Add the protocol name to the layers only if told to
         * do so. Asn2wrs generated dissectors may be added
         * multiple times otherwise.
         */
        /* XXX Should we check for a duplicate layer here? */
        if (add_proto_name) {
            add_layer(pinfo, proto_get_id(handle->protocol));
        }
    }

//    if (pinfo->flags.in_error_pkt) {
//        len = call_dissector_work_error(handle, tvb, pinfo, tree, data);
//    } else {
        /*
         * Just call the subdissector.
         */
        len = call_dissector_through_handle(handle, tvb, pinfo, tree, data);
//    }
//    consumed_none = len == 0 || (pinfo->desegment_len != saved_desegment_len && pinfo->desegment_offset == 0);
    /* If len == 0, then the dissector didn't accept the packet.
     * In the latter case, the dissector accepted the packet, but didn't
     * consume any bytes because they all belong in a later segment.
     * In the latter case, we probably won't call a dissector here again
     * on the next pass, so removing the layer keeps any *further* layers
     * past this one the same on subsequent passes.
     *
     * XXX: DISSECTOR_ASSERT that the tree count didn't change? If the
     * dissector didn't consume any bytes but added items to the tree,
     * that's improper behavior and needs a rethink. We could also move the
     * test that the packet didn't change desegment_offset and desegment_len
     * while rejecting the packet from packet-tcp.c decode_tcp_ports to here.
     */
//    if (handle->protocol != NULL && !proto_is_pino(handle->protocol) && add_proto_name &&
//        (consumed_none || (tree && saved_tree_count == tree->tree_data->count))) {
        /*
         * We've added a layer and either the dissector didn't
         * consume any data or we didn't add any items to the
         * tree. Remove it.
         */
//        while (wmem_list_count(pinfo->layers) > saved_layers_len) {
//            /*
//             * Only reduce the layer number if the dissector didn't
//             * consume any data. Since tree can be NULL on
//             * the first pass, we cannot check it or it will
//             * break dissectors that rely on a stable value.
//             */
//            remove_last_layer(pinfo, consumed_none);
//        }
//    }
    pinfo->proto_name = saved_proto;
//    pinfo->can_desegment = saved_can_desegment;
    return len;
}




/*
 * An entry in the hash table portion of a dissector table.
 */
struct dtbl_entry {
    dissector_handle_t initial;
    dissector_handle_t current;
};

/* Finds a dissector table by table name. */
dissector_table_t find_dissector_table(const char *name)
{
    dissector_table_t dissector_table = (dissector_table_t) g_hash_table_lookup(dissector_tables, name);
    if (! dissector_table) {
        const char *new_name = (const char *) g_hash_table_lookup(dissector_table_aliases, name);
        if (new_name) {
            dissector_table = (dissector_table_t) g_hash_table_lookup(dissector_tables, new_name);
        }
        if (dissector_table) {
//            ws_warning("%s is now %s", name, new_name);
        }
    }
    return dissector_table;
}


static gboolean dissector_delete_all_check (void *key, void *value, void *user_data)
{
    dtbl_entry_t *dtbl_entry = (dtbl_entry_t *) value;
    dissector_handle_t handle = (dissector_handle_t) user_data;

    if (!dtbl_entry->current->protocol) {
        /*
         * Not all dissectors are registered with a protocol, so we need this
         * check when running from dissector_delete_from_all_tables.
         */
        return FALSE;
    }

    return (proto_get_id (dtbl_entry->current->protocol) == proto_get_id (handle->protocol));
}

/* Delete all entries from a dissector table. */
void dissector_delete_all(const char *name, dissector_handle_t handle)
{
    dissector_table_t sub_dissectors = find_dissector_table(name);
//    ws_assert (sub_dissectors);

    g_hash_table_foreach_remove (sub_dissectors->hash_table, dissector_delete_all_check, handle);
}

static void dissector_delete_from_table(gpointer key, gpointer value, gpointer user_data)
{
    dissector_table_t sub_dissectors = (dissector_table_t) value;
//    ws_assert (sub_dissectors);

    g_hash_table_foreach_remove(sub_dissectors->hash_table, dissector_delete_all_check, user_data);
    sub_dissectors->dissector_handles = g_slist_remove(sub_dissectors->dissector_handles, user_data);
}

/* Delete handle from all tables and dissector_handles lists */
static void dissector_delete_from_all_tables(dissector_handle_t handle)
{
    g_hash_table_foreach(dissector_tables, dissector_delete_from_table, handle);
}

/* Add an entry to a "custom" dissector table. */
void dissector_add_custom_table_handle(const char *name, void *pattern, dissector_handle_t handle)
{
    dissector_table_t  sub_dissectors = find_dissector_table(name);
    dtbl_entry_t      *dtbl_entry;

    /*
     * Make sure the handle and the dissector table exist.
     */
    if (handle == NULL) {
        fprintf(stderr, "OOPS: handle to register \"%s\" to doesn't exist\n",
            name);
//        if (wireshark_abort_on_dissector_bug)
//            abort();
        return;
    }
    if (sub_dissectors == NULL) {
        fprintf(stderr, "OOPS: dissector table \"%s\" doesn't exist\n",
            name);
        fprintf(stderr, "Protocol being registered is \"%s\"\n",
            proto_get_protocol_long_name(handle->protocol));
//        if (wireshark_abort_on_dissector_bug)
//            abort();
        return;
    }

//    ws_assert(sub_dissectors->type == FT_BYTES);

    dtbl_entry = g_new(dtbl_entry_t, 1);
    dtbl_entry->current = handle;
    dtbl_entry->initial = dtbl_entry->current;

    /* do the table insertion */
    g_hash_table_insert(sub_dissectors->hash_table, (void *)pattern,
                 (void *)dtbl_entry);
}

dissector_handle_t dissector_get_custom_table_handle(dissector_table_t sub_dissectors, void *key)
{
    dtbl_entry_t *dtbl_entry = (dtbl_entry_t *)g_hash_table_lookup(sub_dissectors->hash_table, key);

    if (dtbl_entry != NULL)
        return dtbl_entry->current;

    return NULL;
}

static int dissector_compare_filter_name(const void *dissector_a, const void *dissector_b)
{
    const struct dissector_handle *a = (const struct dissector_handle *)dissector_a;
    const struct dissector_handle *b = (const struct dissector_handle *)dissector_b;
    const char *a_name, *b_name;
    int ret;

    if (a->protocol == NULL)
        a_name = "";
    else
        a_name = proto_get_protocol_filter_name(proto_get_id(a->protocol));

    if (b->protocol == NULL)
        b_name = "";
    else
        b_name = proto_get_protocol_filter_name(proto_get_id(b->protocol));

    ret = strcmp(a_name, b_name);
    return ret;
}

dissector_handle_t dtbl_entry_get_initial_handle (dtbl_entry_t *dtbl_entry)
{
    return dtbl_entry->initial;
}

GSList *dissector_table_get_dissector_handles(dissector_table_t dissector_table) {
    if (!dissector_table)
        return NULL;

    return dissector_table->dissector_handles;
}

/*
 * Data structure used as user data when iterating dissector handles
 */
typedef struct lookup_entry {
    const char* dissector_description;
    dissector_handle_t handle;
} lookup_entry_t;

/*
 * A callback function to changed a dissector_handle if matched
 * This is used when iterating a dissector table
 */
static void find_dissector_in_table(void *item, void *user_data)
{
    dissector_handle_t handle = (dissector_handle_t)item;
    lookup_entry_t * lookup = (lookup_entry_t *)user_data;
    const char *description = dissector_handle_get_description(handle);
    if (description && strcmp(lookup->dissector_description, description) == 0) {
        lookup->handle = handle;
    }
}

dissector_handle_t dissector_table_get_dissector_handle(dissector_table_t dissector_table, const char* description)
{
    lookup_entry_t lookup;

    lookup.dissector_description = description;
    lookup.handle = NULL;

    g_slist_foreach(dissector_table->dissector_handles, find_dissector_in_table, &lookup);
    return lookup.handle;
}

ftenum_t dissector_table_get_type(dissector_table_t dissector_table) {
    if (!dissector_table) return FT_NONE;
    return dissector_table->type;
}

//static int
//uuid_equal(const void *k1, const void *k2)
//{
//    const guid_key *key1 = (const guid_key *)k1;
//    const guid_key *key2 = (const guid_key *)k2;
//    return ((memcmp(&key1->guid, &key2->guid, sizeof (e_guid_t)) == 0)
//        && (key1->ver == key2->ver));
//}

//static unsigned
//uuid_hash(const void *k)
//{
//    const guid_key *key = (const guid_key *)k;
//    /* This isn't perfect, but the Data1 part of these is almost always unique. */
//    return key->guid.data1;
//}

/**************************************************/
/*                                                */
/*       Routines to walk dissector tables        */
/*                                                */
/**************************************************/

typedef struct dissector_foreach_info {
    void *        caller_data;
    DATFunc       caller_func;
    GHFunc        next_func;
    const char   *table_name;
    ftenum_t      selector_type;
} dissector_foreach_info_t;

/*
 * Called for each entry in a dissector table.
 */
static void dissector_table_foreach_func (void *key, void *value, void *user_data)
{
    dissector_foreach_info_t *info;
    dtbl_entry_t             *dtbl_entry;

//    ws_assert(value);
//    ws_assert(user_data);

    dtbl_entry = (dtbl_entry_t *)value;
    if (dtbl_entry->current == NULL ||
        dtbl_entry->current->protocol == NULL) {
        /*
         * Either there is no dissector for this entry, or
         * the dissector doesn't have a protocol associated
         * with it.
         *
         * XXX - should the latter check be done?
         */
        return;
    }

    info = (dissector_foreach_info_t *)user_data;
    info->caller_func(info->table_name, info->selector_type, key, value,
              info->caller_data);
}

/*
 * Called for each entry in the table of all dissector tables.
 */
static void dissector_all_tables_foreach_func (void *key, void *value, void *user_data)
{
    dissector_table_t         sub_dissectors;
    dissector_foreach_info_t *info;

//    ws_assert(value);
//    ws_assert(user_data);

    sub_dissectors = (dissector_table_t)value;
    info = (dissector_foreach_info_t *)user_data;
    info->table_name = (char*) key;
    info->selector_type = get_dissector_table_selector_type(info->table_name);
    g_hash_table_foreach(sub_dissectors->hash_table, info->next_func, info);
}

/*
 * Walk all dissector tables calling a user supplied function on each
 * entry.
 */
static void dissector_all_tables_foreach (DATFunc func,
                  void *user_data)
{
    dissector_foreach_info_t info;

    info.caller_data = user_data;
    info.caller_func = func;
    info.next_func   = dissector_table_foreach_func;
    g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_func, &info);
}

/*
 * Walk one dissector table's hash table calling a user supplied function
 * on each entry.
 */
void dissector_table_foreach (const char *table_name,
             DATFunc     func,
             void *      user_data)
{
    dissector_foreach_info_t info;
    dissector_table_t        sub_dissectors = find_dissector_table(table_name);

    info.table_name    = table_name;
    info.selector_type = sub_dissectors->type;
    info.caller_func   = func;
    info.caller_data   = user_data;
    g_hash_table_foreach(sub_dissectors->hash_table, dissector_table_foreach_func, &info);
}

/*
 * Walk one dissector table's list of handles calling a user supplied
 * function on each entry.
 */
void dissector_table_foreach_handle(const char     *table_name,
                   DATFunc_handle  func,
                   void *          user_data)
{
    dissector_table_t sub_dissectors = find_dissector_table(table_name);
    GSList *tmp;

    for (tmp = sub_dissectors->dissector_handles; tmp != NULL;
         tmp = g_slist_next(tmp))
        func(table_name, tmp->data, user_data);
}

/*
 * Called for each entry in a dissector table.
 */
static void dissector_table_foreach_changed_func (void *key, void *value, void *user_data)
{
    dtbl_entry_t             *dtbl_entry;
    dissector_foreach_info_t *info;

//    ws_assert(value);
//    ws_assert(user_data);

    dtbl_entry = (dtbl_entry_t *)value;
    if (dtbl_entry->initial == dtbl_entry->current) {
        /*
         * Entry hasn't changed - don't call the function.
         */
        return;
    }

    info = (dissector_foreach_info_t *)user_data;
    info->caller_func(info->table_name, info->selector_type, key, value,
              info->caller_data);
}

/*
 * Walk all dissector tables calling a user supplied function only on
 * any entry that has been changed from its original state.
 */
void dissector_all_tables_foreach_changed (DATFunc  func,
                      void *user_data)
{
    dissector_foreach_info_t info;

    info.caller_data = user_data;
    info.caller_func = func;
    info.next_func   = dissector_table_foreach_changed_func;
    g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_func, &info);
}

/*
 * Walk one dissector table calling a user supplied function only on
 * any entry that has been changed from its original state.
 */
void dissector_table_foreach_changed (const char *table_name,
                 DATFunc     func,
                 void *      user_data)
{
    dissector_foreach_info_t info;
    dissector_table_t sub_dissectors = find_dissector_table(table_name);

    info.table_name    = table_name;
    info.selector_type = sub_dissectors->type;
    info.caller_func   = func;
    info.caller_data   = user_data;
    g_hash_table_foreach(sub_dissectors->hash_table,
                 dissector_table_foreach_changed_func, &info);
}

typedef struct dissector_foreach_table_info {
    void *        caller_data;
    DATFunc_table caller_func;
} dissector_foreach_table_info_t;

/*
 * Called for each entry in the table of all dissector tables.
 * This is used if we directly process the hash table.
 */
static void dissector_all_tables_foreach_table_func (void *key, void *value, void *user_data)
{
    dissector_table_t               table;
    dissector_foreach_table_info_t *info;

    table = (dissector_table_t)value;
    info  = (dissector_foreach_table_info_t *)user_data;
    (*info->caller_func)((char *)key, table->ui_name, info->caller_data);
}

/*
 * Called for each key in the table of all dissector tables.
 * This is used if we get a list of table names, sort it, and process the list.
 */
static void dissector_all_tables_foreach_list_func (void *key, void *user_data)
{
    dissector_table_t               table;
    dissector_foreach_table_info_t *info;

    table = (dissector_table_t)g_hash_table_lookup(dissector_tables, key);
    info  = (dissector_foreach_table_info_t *)user_data;
    (*info->caller_func)((char*)key, table->ui_name, info->caller_data);
}

/*
 * Walk all dissector tables calling a user supplied function on each
 * table.
 */
void dissector_all_tables_foreach_table (DATFunc_table func,
                    void *        user_data,
                    GCompareFunc  compare_key_func)
{
    dissector_foreach_table_info_t info;
    GList *list;

    info.caller_data = user_data;
    info.caller_func = func;
    if (compare_key_func != NULL)
    {
        list = g_hash_table_get_keys(dissector_tables);
        list = g_list_sort(list, compare_key_func);
        g_list_foreach(list, dissector_all_tables_foreach_list_func, &info);
        g_list_free(list);
    }
    else
    {
        g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_table_func, &info);
    }
}

dissector_table_t register_dissector_table(const char *name, const char *ui_name, const int proto, const ftenum_t type,
             const int param)
{
    dissector_table_t    sub_dissectors;

    /* Make sure the registration is unique */
    if (g_hash_table_lookup(dissector_tables, name)) {
        printf("The dissector table %s (%s) is already registered - are you using a buggy plugin?", name, ui_name);
    }

    /* Create and register the dissector table for this name; returns */
    /* a pointer to the dissector table. */
    sub_dissectors = g_slice_new(struct dissector_table);
    switch (type) {

    case FT_UINT8:
    case FT_UINT16:
    case FT_UINT24:
    case FT_UINT32:
        /*
         * XXX - there's no "g_uint_hash()" or "g_uint_equal()",
         * so we use "g_direct_hash()" and "g_direct_equal()".
         */
        sub_dissectors->hash_func = g_direct_hash;
        sub_dissectors->hash_table = g_hash_table_new_full(g_direct_hash,
                                   g_direct_equal,
                                   NULL,
                                   &g_free);
        break;

    case FT_STRING:
    case FT_STRINGZ:
    case FT_STRINGZPAD:
    case FT_STRINGZTRUNC:
        sub_dissectors->hash_func = g_str_hash;
        sub_dissectors->hash_table = g_hash_table_new_full(g_str_hash,
                                   g_str_equal,
                                   &g_free,
                                   &g_free);
        break;
    case FT_GUID:
//        sub_dissectors->hash_table = g_hash_table_new_full(uuid_hash,
//                                   uuid_equal,
//                                   NULL,
//                                   &g_free);
        break;

    case FT_NONE:
        /* Dissector tables with FT_NONE don't have values associated with
           dissectors so this will always be a hash table size of 1 just
           to store the single dtbl_entry_t */
        sub_dissectors->hash_func = g_direct_hash;
        sub_dissectors->hash_table = g_hash_table_new_full(g_direct_hash,
                                   g_direct_equal,
                                   NULL,
                                   &g_free);
        break;

    default:
//        printf("The dissector table %s (%s) is registering an unsupported type - are you using a buggy plugin?", name, ui_name);
//        ws_assert_not_reached();
        break;
    }
    sub_dissectors->dissector_handles = NULL;
    sub_dissectors->ui_name = ui_name;
    sub_dissectors->type    = type;
    sub_dissectors->param   = param;
    sub_dissectors->protocol  = (proto == -1) ? NULL : find_protocol_by_id(proto);

    g_hash_table_insert(dissector_tables, (void *)name, (void *) sub_dissectors);
    return sub_dissectors;
}

dissector_table_t register_custom_dissector_table(const char *name,
    const char *ui_name, const int proto, GHashFunc hash_func, GEqualFunc key_equal_func,
    GDestroyNotify key_destroy_func)
{
    dissector_table_t    sub_dissectors;

    /* Make sure the registration is unique */
    if (g_hash_table_lookup(dissector_tables, name)) {
        printf("The dissector table %s (%s) is already registered - are you using a buggy plugin?", name, ui_name);
    }

    /* Create and register the dissector table for this name; returns */
    /* a pointer to the dissector table. */
    sub_dissectors = g_slice_new(struct dissector_table);
    sub_dissectors->hash_func = hash_func;
    sub_dissectors->hash_table = g_hash_table_new_full(hash_func,
                                   key_equal_func,
                                   key_destroy_func,
                                   &g_free);

    sub_dissectors->dissector_handles = NULL;
    sub_dissectors->ui_name = ui_name;
    sub_dissectors->type    = FT_BYTES; /* Consider key a "blob" of data, no need to really create new type */
    sub_dissectors->param   = BASE_NONE;
    sub_dissectors->protocol  = (proto == -1) ? NULL : find_protocol_by_id(proto);

    g_hash_table_insert(dissector_tables, (void *)name, (void *) sub_dissectors);
    return sub_dissectors;
}

void register_dissector_table_alias(dissector_table_t dissector_table, const char *alias_name) {
    if (!dissector_table || !alias_name) return;

    const char *name = NULL;
    GList *list = g_hash_table_get_keys(dissector_tables);
    for (GList *cur = list; cur; cur = cur->next) {
        if (g_hash_table_lookup(dissector_tables, cur->data) == dissector_table) {
            name = (const char *) cur->data;
            break;
        }
    }
    g_list_free(list);
    if (!name) return;

    g_hash_table_insert(dissector_table_aliases, (void *) alias_name, (void *) name);
}

void deregister_dissector_table(const char *name)
{
    dissector_table_t sub_dissectors = (dissector_table_t) g_hash_table_lookup(dissector_tables, name);
    if (!sub_dissectors) return;

    g_hash_table_remove(dissector_tables, name);

    GList *list = g_hash_table_get_keys(dissector_table_aliases);
    for (GList *cur = list; cur; cur = cur->next) {
        void *alias_name = cur->data;
        if (g_hash_table_lookup(dissector_table_aliases, alias_name) == name) {
            g_hash_table_remove(dissector_table_aliases, alias_name);
        }
    }
    g_list_free(list);
}

const char *get_dissector_table_ui_name(const char *name)
{
    dissector_table_t sub_dissectors = find_dissector_table(name);
    if (!sub_dissectors) return NULL;

    return sub_dissectors->ui_name;
}

ftenum_t get_dissector_table_selector_type(const char *name)
{
    dissector_table_t sub_dissectors = find_dissector_table(name);
    if (!sub_dissectors) return FT_NONE;

    return sub_dissectors->type;
}

int get_dissector_table_param(const char *name)
{
    dissector_table_t sub_dissectors = find_dissector_table(name);
    if (!sub_dissectors) return 0;

    return sub_dissectors->param;
}

/*
 * Register dissectors by name; used if one dissector always calls a
 * particular dissector, or if it bases the decision of which dissector
 * to call on something other than a numerical value or on "try a bunch
 * of dissectors until one likes the packet".
 */

/* Get the long name of the protocol for a dissector handle, if it has
   a protocol. */
const char *dissector_handle_get_protocol_long_name(const dissector_handle_t handle)
{
    if (handle == NULL || handle->protocol == NULL) {
        return NULL;
    }
    return proto_get_protocol_long_name(handle->protocol);
}

/* Get the short name of the protocol for a dissector handle, if it has
   a protocol. */
const char *dissector_handle_get_protocol_short_name(const dissector_handle_t handle)
{
    if (handle == NULL || handle->protocol == NULL) {
        return NULL;
    }
    return proto_get_protocol_short_name(handle->protocol);
}

/* For backwards source and binary compatibility */
const char *dissector_handle_get_short_name(const dissector_handle_t handle)
{
    return dissector_handle_get_protocol_short_name(handle);
}

/* Get the description for what the dissector in the dissector handle
   dissects, if it has one. */
const char *dissector_handle_get_description(const dissector_handle_t handle)
{
    if (handle == NULL) {
        return NULL;
    }
    return handle->description;
}

/* Get the index of the protocol for a dissector handle, if it has
   a protocol. */
int dissector_handle_get_protocol_index(const dissector_handle_t handle)
{
    if (handle->protocol == NULL) {
        /*
         * No protocol (see, for example, the handle for
         * dissecting the set of protocols where the first
         * octet of the payload is an OSI network layer protocol
         * ID).
         */
        return -1;
    }
    return proto_get_id(handle->protocol);
}

/* Get a GList of all registered dissector names. The content of the list
   is owned by the hash table and should not be modified or freed.
   Use g_list_free() when done using the list. */
GList *get_dissector_names(void)
{
    if (!registered_dissectors) {
        return NULL;
    }

    return g_hash_table_get_keys(registered_dissectors);
}

/* Find a registered dissector by name. */
dissector_handle_t find_dissector(const char *name)
{
    return (dissector_handle_t)g_hash_table_lookup(registered_dissectors, name);
}

/** Find a dissector by name and add parent protocol as a dependency*/
dissector_handle_t find_dissector_add_dependency(const char *name, const int parent_proto)
{
    dissector_handle_t handle = (dissector_handle_t)g_hash_table_lookup(registered_dissectors, name);
    if ((handle != NULL) && (parent_proto > 0))
    {
        register_depend_dissector(proto_get_protocol_short_name(find_protocol_by_id(parent_proto)), dissector_handle_get_protocol_short_name(handle));
    }

    return handle;
}

/* Get a dissector name from handle. */
const char *dissector_handle_get_dissector_name(const dissector_handle_t handle)
{
    if (handle == NULL) {
        return NULL;
    }
    return handle->name;
}

const char *dissector_handle_get_pref_suffix(const dissector_handle_t handle)
{
    if (handle == NULL) {
        return "";
    }
    return handle->pref_suffix ? handle->pref_suffix : "";
}

static void check_valid_dissector_name_or_fail(const char *name)
{
    if (proto_check_field_name(name)) {
        printf("Dissector name \"%s\" has one or more invalid characters."
            " Allowed are letters, digits, '-', '_' and non-repeating '.'."
            " This might be caused by an inappropriate plugin or a development error.", name);
    }
}

static dissector_handle_t new_dissector_handle(const int proto, const char *name, const char *description)
{
    struct dissector_handle *handle;

    /* Make sure name is "parsing friendly" - descriptions should be
     * used for complicated phrases. NULL for anonymous unregistered
     * dissectors is allowed; we check for that in various places.
     *
     * (It might be safer to have a default name used for anonymous
     * dissectors rather than NULL checks scattered in the code.)
     */
    if (name) {
        check_valid_dissector_name_or_fail(name);
    }

    handle            = malloc(sizeof(struct dissector_handle));
    handle->name        = name;
    handle->description    = description;
    handle->protocol    = find_protocol_by_id(proto);
    handle->pref_suffix     = NULL;

    if (handle->description == NULL) {
        /*
         * No description for what this dissector dissects
         * was supplied; use the short name for the protocol,
         * if we have the protocol.
         *
         * (We may have no protocol; see, for example, the handle
         * for dissecting the set of protocols where the first
         * octet of the payload is an OSI network layer protocol
         * ID.)
         */
        if (handle->protocol != NULL)
            handle->description = proto_get_protocol_short_name(handle->protocol);
    } else {
        if (name && g_strcmp0(name, proto_get_protocol_filter_name(proto)) != 0) {
            char *suffix = malloc(strlen(name)+2);
            snprintf(suffix, strlen(name)+2, ".%s", name);
            handle->pref_suffix = ascii_tolower(suffix); free(suffix);
            char *pos = handle->pref_suffix;
            while ((pos = strchr(pos, '-')) != NULL) {
                *pos++ = '_';
            }
        }
    }
    return handle;
}

dissector_handle_t create_dissector_handle_with_name_and_description(dissector_t dissector,
                        const int proto,
                        const char* name,
                        const char* description)
{
    dissector_handle_t handle;

    handle = new_dissector_handle(proto, name, description);
    handle->dissector_type = DISSECTOR_TYPE_SIMPLE;
    handle->dissector_func.dissector_type_simple = dissector;
    handle->dissector_data = NULL;
    return handle;
}

dissector_handle_t create_dissector_handle_with_name(dissector_t dissector,
                const int proto, const char* name)
{
    return create_dissector_handle_with_name_and_description(dissector, proto, name, NULL);
}

/* Create an anonymous handle for a new dissector. */
dissector_handle_t create_dissector_handle(dissector_t dissector, const int proto)
{
    return create_dissector_handle_with_name_and_description(dissector, proto, NULL, NULL);
}

/* Destroy an anonymous handle for a dissector. */
static void destroy_dissector_handle(dissector_handle_t handle)
{
    if (handle == NULL) return;

    dissector_delete_from_all_tables(handle);
    deregister_postdissector(handle);
//    if (handle->pref_suffix) {
//        wmem_free(wmem_epan_scope(), handle->pref_suffix);
//    }
//    wmem_free(wmem_epan_scope(), handle);
}

static dissector_handle_t register_dissector_handle(const char *name, dissector_handle_t handle)
{
    bool new_entry;

    /* A registered dissector should have a name. */
    if (name == NULL || name[0] == '\0') {
        printf("A registered dissector name cannot be NULL or the empty string."
            " Anonymous dissector handles can be created with create_dissector_handle()."
            " This might be caused by an inappropriate plugin or a development error.");
    }

    new_entry = g_hash_table_insert(registered_dissectors, (void *)name, handle);
    if (!new_entry) {
        /* Make sure the registration is unique */
        printf("dissector handle name \"%s\" is already registered", name);
    }

    return handle;
}

/* Register a new dissector by name. */
dissector_handle_t register_dissector(const char *name, dissector_t dissector, const int proto)
{
    dissector_handle_t handle;

    handle = create_dissector_handle_with_name(dissector, proto, name);

    return register_dissector_handle(name, handle);
}

dissector_handle_t register_dissector_with_description(const char *name, const char *description, dissector_t dissector, const int proto)
{
    dissector_handle_t handle;

    handle = create_dissector_handle_with_name_and_description(dissector, proto, name, description);

    return register_dissector_handle(name, handle);
}

static bool remove_depend_dissector_from_list(depend_dissector_list_t sub_dissectors, const char *dependent)
{
    GSList *found_entry;

    found_entry = g_slist_find_custom(sub_dissectors->dissectors,
        dependent, (GCompareFunc)strcmp);

    if (found_entry) {
        g_free(found_entry->data);
        sub_dissectors->dissectors = g_slist_delete_link(sub_dissectors->dissectors, found_entry);
        return true;
    }

    return false;
}

static void remove_depend_dissector_ghfunc(void *key, void *value, void *user_data)
{
    depend_dissector_list_t sub_dissectors = (depend_dissector_list_t) value;
    const char *dependent = (const char *)user_data;

    remove_depend_dissector_from_list(sub_dissectors, dependent);
}

/* Deregister a dissector by name. */
void deregister_dissector(const char *name)
{
    dissector_handle_t handle = find_dissector(name);
    if (handle == NULL) return;

    g_hash_table_remove(registered_dissectors, name);
    g_hash_table_remove(depend_dissector_lists, name);
    g_hash_table_foreach(depend_dissector_lists, remove_depend_dissector_ghfunc, (void *)name);

    destroy_dissector_handle(handle);
}

int call_dissector(dissector_handle_t handle, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{printf("call_dissector: %s, %p, %p\n", handle->name, tvb, tree);fflush(stdout);
    return call_dissector_work(handle, tvb, pinfo, tree, true, NULL);
}

static int find_matching_proto_name(const void *arg1, const void *arg2)
{
    const char    *protocol_name = (const char*)arg1;
    const char    *name   = (const char *)arg2;

    return strcmp(protocol_name, name);
}

bool register_depend_dissector(const char* parent, const char* dependent)
{
    GSList                *list_entry;
    depend_dissector_list_t sub_dissectors;

    if ((parent == NULL) || (dependent == NULL))
    {
        /* XXX - assert on parent? */
        return false;
    }

    sub_dissectors = find_depend_dissector_list(parent);
    if (sub_dissectors == NULL) {
        /* parent protocol doesn't exist, create it */
        sub_dissectors = g_slice_new(struct depend_dissector_list);
        sub_dissectors->dissectors = NULL;    /* initially empty */
        g_hash_table_insert(depend_dissector_lists, (void *)g_strdup(parent), (void *) sub_dissectors);
    }

    /* Verify that sub-dissector is not already in the list */
    list_entry = g_slist_find_custom(sub_dissectors->dissectors, (void *)dependent, find_matching_proto_name);
    if (list_entry != NULL)
        return true; /* Dependency already exists */

    sub_dissectors->dissectors = g_slist_prepend(sub_dissectors->dissectors, (void *)g_strdup(dependent));
    return true;
}

bool deregister_depend_dissector(const char* parent, const char* dependent)
{
    depend_dissector_list_t  sub_dissectors = find_depend_dissector_list(parent);

    /* sanity check */
//    ws_assert(sub_dissectors != NULL);

    return remove_depend_dissector_from_list(sub_dissectors, dependent);
}

depend_dissector_list_t find_depend_dissector_list(const char* name)
{
    return (depend_dissector_list_t)g_hash_table_lookup(depend_dissector_lists, name);
}

/*
 * Dumps the "layer type"/"decode as" associations to stdout, similar
 * to the proto_registrar_dump_*() routines.
 *
 * There is one record per line. The fields are tab-delimited.
 *
 * Field 1 = layer type, e.g. "tcp.port"
 * Field 2 = selector - decimal for integer tables, strings for string tables,
 *           blank for payload tables. Custom and GUID tables aren't shown.
 *           (XXX - Should integer tables respect the table base, e.g. use hex?)
 * Field 3 = "decode as" name, e.g. "http"
 *
 * XXX - View -> Internals -> Dissector Tables in the GUI includes the UI name,
 * and separates tables by category. We could add fields for the the UI name
 * and category.
 *
 * The GUI doesn't display FT_NONE (it should) nor FT_GUID tables, but does
 * FT_BYTES (Custom) tables with the handle description name as key.
 * That may or may not be helpful.
 */


static void dissector_dump_decodes_display(const char *table_name,
                   ftenum_t selector_type, void *key, void *value)
{
    dissector_table_t   sub_dissectors = find_dissector_table(table_name);
    dtbl_entry_t       *dtbl_entry;
    dissector_handle_t  handle;
    int                 proto_id;
    const char         *decode_as;

    dtbl_entry = (dtbl_entry_t *)value;
//    ws_assert(dtbl_entry);

    handle   = dtbl_entry->current;
//    ws_assert(handle);

    proto_id = dissector_handle_get_protocol_index(handle);

    if (proto_id != -1) {
        decode_as = proto_get_protocol_filter_name(proto_id);
        switch (sub_dissectors->type) {
            case FT_UINT8:
            case FT_UINT16:
            case FT_UINT24:
            case FT_UINT32:
                printf("%s\t%u\t%s\n", table_name, GPOINTER_TO_UINT(key), decode_as);
                break;

            case FT_STRING:
                printf("%s\t%s\t%s\n", table_name, (char*)key, decode_as);
                break;

            case FT_NONE:
                printf("%s\t\t%s\n", table_name, decode_as);
                break;

            case FT_GUID:
                // We could output something here with the guid_key
                break;

            case FT_BYTES:
                // View->Internals->Dissector Tables uses the description,
                // but that doesn't tell anything about how the table is
                // configured. (This isn't a list of all possible handles.)
                // Is it useful to output?
                break;

            default:
                break;
        }
    }
}

static int compare_ints(const void *a, const void *b)
{
    uint32_t inta, intb;

    inta = GPOINTER_TO_UINT(a);
    intb = GPOINTER_TO_UINT(b);

    if (inta < intb)
        return -1;
    if (inta > intb)
        return 1;
    return 0;
}

static void dissector_dump_table_decodes(const char *table_name, const char *ui_name, void *user_data)
{
    dissector_table_t   sub_dissectors = find_dissector_table(table_name);
    GList *keys;

//    ws_assert(sub_dissectors);
    keys = g_hash_table_get_keys(sub_dissectors->hash_table);

    switch (sub_dissectors->type) {
        case FT_UINT8:
        case FT_UINT16:
        case FT_UINT24:
        case FT_UINT32:
            keys = g_list_sort(keys, compare_ints);
            break;

        case FT_STRING:
        case FT_STRINGZ:
        case FT_UINT_STRING:
        case FT_STRINGZPAD:
        case FT_STRINGZTRUNC:
            keys = g_list_sort(keys, (GCompareFunc)strcmp);
            break;

        /* FT_NONE we don't need to sort. We could do something for
         * FT_GUID and FT_BYTES (Custom) if we were to output them,
         * possibly with g_list_sort_with_data.
         */
        default:
            break;
    }

    for (GList *entry = g_list_first(keys); entry; entry = entry->next) {
        void *key = entry->data;
        void *value = g_hash_table_lookup(sub_dissectors->hash_table, key);
        dissector_dump_decodes_display(table_name, sub_dissectors->type, key, value);
    }

    g_list_free(keys);
}

void dissector_dump_decodes(void)
{
    dissector_all_tables_foreach_table(dissector_dump_table_decodes, NULL, (GCompareFunc)strcmp);
}

static void dissector_dump_dissector_tables_display (void *key, void *user_data)
{
    const char        *table_name = (const char *)key;
    dissector_table_t    table;

    table = (dissector_table_t)g_hash_table_lookup(dissector_tables, key);
    printf("%s\t%s\t%s", table_name, table->ui_name, ftype_name(table->type));
    switch (table->type) {

    case FT_UINT8:
    case FT_UINT16:
    case FT_UINT24:
    case FT_UINT32:
        switch(table->param) {

        case BASE_NONE:
            printf("\tBASE_NONE");
            break;

        case BASE_DEC:
            printf("\tBASE_DEC");
            break;

        case BASE_HEX:
            printf("\tBASE_HEX");
            break;

        case BASE_DEC_HEX:
            printf("\tBASE_DEC_HEX");
            break;

        case BASE_HEX_DEC:
            printf("\tBASE_HEX_DEC");
            break;

        default:
            printf("\t%d", table->param);
            break;
        }
        break;

    default:
        break;
    }
    if (table->protocol != NULL) {
        printf("\t%s",
            proto_get_protocol_short_name(table->protocol));
    } else
        printf("\t(no protocol)");

    printf("\n");
}

static int compare_dissector_key_name(const void *dissector_a, const void *dissector_b)
{
  return strcmp((const char*)dissector_a, (const char*)dissector_b);
}

void dissector_dump_dissector_tables(void)
{
    GList *list;

    list = g_hash_table_get_keys(dissector_tables);
    list = g_list_sort(list, compare_dissector_key_name);
    g_list_foreach(list, dissector_dump_dissector_tables_display, NULL);
    g_list_free(list);

//    list = g_hash_table_get_keys(heur_dissector_lists);
//    list = g_list_sort(list, compare_dissector_key_name);
//    g_list_foreach(list, dissector_dump_heur_dissector_tables_display, NULL);
//    g_list_free(list);
}

/*
 * Dumps the entries in the table of registered dissectors.
 *
 * There is one record per line. The fields are tab-delimited.
 *
 * Field 1 = dissector name
 * Field 2 = dissector description
 */

struct dissector_info {
    const char *name;
    const char *description;
};

static int compare_dissector_info_names(const void *arg1, const void *arg2)
{
    const struct dissector_info *info1 = (const struct dissector_info *) arg1;
    const struct dissector_info *info2 = (const struct dissector_info *) arg2;

    return strcmp(info1->name, info2->name);
}

void dissector_dump_dissectors(void)
{
    GHashTableIter iter;
        gpointer key, value;
    struct dissector_info *dissectors_info;
    unsigned num_protocols;
    unsigned proto_index;

    g_hash_table_iter_init(&iter, registered_dissectors);
    num_protocols = g_hash_table_size(registered_dissectors);
    dissectors_info = malloc(sizeof(struct dissector_info) * num_protocols);
    proto_index = 0;
    while (g_hash_table_iter_next(&iter, &key, &value)) {
        dissectors_info[proto_index].name = (const char *)key;
        dissectors_info[proto_index].description =
            ((dissector_handle_t) value)->description;
        proto_index++;
    }
    qsort(dissectors_info, num_protocols, sizeof(struct dissector_info),
        compare_dissector_info_names);
    for (proto_index = 0; proto_index < num_protocols; proto_index++) {
        printf("%s\t%s\n", dissectors_info[proto_index].name,
            dissectors_info[proto_index].description);
    }
    free(dissectors_info);
}

void register_postdissector(dissector_handle_t handle)
{
    postdissector p;

    if (!postdissectors)
        postdissectors = g_array_sized_new(false, false, (unsigned)sizeof(postdissector), 1);

    p.handle = handle;
    p.wanted_hfids = NULL;
    postdissectors = g_array_append_val(postdissectors, p);
}

void deregister_postdissector(dissector_handle_t handle)
{
    unsigned i;

    if (!postdissectors) return;

    for (i = 0; i < postdissectors->len; i++) {
        if (POSTDISSECTORS(i).handle == handle) {
            if (POSTDISSECTORS(i).wanted_hfids) {
                g_array_free(POSTDISSECTORS(i).wanted_hfids, true);
            }
            postdissectors = g_array_remove_index_fast(postdissectors, i);
            break;
        }
    }
}

bool have_postdissector(void)
{
    unsigned i;
    dissector_handle_t handle;

    for (i = 0; i < postdissectors->len; i++) {
        handle = POSTDISSECTORS(i).handle;

        if (handle->protocol != NULL
            && proto_is_protocol_enabled(handle->protocol)) {
            /* We have at least one enabled postdissector */
            return true;
        }
    }
    return false;
}

void increment_dissection_depth(packet_info *pinfo)
{
    pinfo->dissection_depth++;
//    DISSECTOR_ASSERT(pinfo->dissection_depth < (int)prefs.gui_max_tree_depth);
}

void decrement_dissection_depth(packet_info *pinfo)
{
    pinfo->dissection_depth--;
    DISSECTOR_ASSERT(pinfo->dissection_depth >= 0);
}
